home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / private / pdcwin.c < prev   
Encoding:
C/C++ Source or Header  |  1995-01-26  |  6.6 KB  |  267 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. #ifndef NO_MEMORY_H
  24. #include <memory.h>
  25. #endif
  26.  
  27. #ifdef PDCDEBUG
  28. char *rcsid_PDCwin  = "$Id$";
  29. #endif
  30.  
  31. /*man-start*********************************************************************
  32.  
  33.   PDC_copy_win()    - Common routine for copywin(), overlay() and overwrite()
  34.      functions.
  35.  
  36.   PDCurses Description:
  37.      This function copies the region of the source window specified
  38.      over the specified region of the destination window. All validation
  39.      of limits are done by the calling function.
  40.  
  41.      Thanks to Andreas Otte (venn@uni-paderborn.de) for the code changes.
  42.  
  43.   PDCurses Errors:
  44.      ERR is returned if either src or dst windows are NULL;
  45.  
  46.   Portability:
  47.      PDCurses    int    PDC_copy_win( WINDOW* src_w, WINDOW* dst_w
  48.              int src_tr,int src_tc,int src_br,int src_bc,
  49.              int dst_tr,int dst_tc,int dst_br,int dst_bc,bool overlay);
  50.  
  51. **man-end**********************************************************************/
  52.  
  53. int    PDC_copy_win(WINDOW *src_w, WINDOW *dst_w,
  54.              int src_tr,int src_tc,int src_br,int src_bc,
  55.              int dst_tr,int dst_tc,int dst_br,int dst_bc,bool overlay)
  56. {
  57.     int*    minchng=0;
  58.     int*    maxchng=0;
  59.     chtype*    w1ptr=NULL;
  60.     chtype*    w2ptr=NULL;
  61.     int    col=0;
  62.     int    line=0;
  63.     int    xdiff = src_bc - src_tc;
  64.     int    ydiff = src_br - src_tr;
  65.     int    y1=0;
  66.  
  67. #ifdef PDCDEBUG
  68.     if (trace_on) PDC_debug("PDC_copy_win() - called\n");
  69. #endif
  70.  
  71.     if (src_w == (WINDOW *)NULL)    return( ERR );
  72.     if (dst_w == (WINDOW *)NULL)    return( ERR );
  73.  
  74.     minchng    = dst_w->_firstch;
  75.     maxchng    = dst_w->_lastch;
  76.  
  77.  
  78.     for (y1 = 0; y1 < dst_tr; y1++)
  79.         {
  80.         minchng++;
  81.         maxchng++;
  82.         }
  83.  
  84.     for (line = 0; line < ydiff; line++)
  85.     {
  86.         register int fc;
  87.         register int lc;
  88.  
  89.         w1ptr = src_w->_y[line+src_tr]+src_tc;
  90.         w2ptr = dst_w->_y[line+dst_tr]+dst_tc;
  91.         fc    = _NO_CHANGE;
  92.  
  93.         for (col = 0; col < xdiff; col++)
  94.         {
  95.             if ((*w1ptr) != (*w2ptr)
  96.             &&  !((*w1ptr & A_CHARTEXT) == src_w->_blank && overlay))
  97.             {
  98.                 *w2ptr = *w1ptr;
  99.                 if (fc == _NO_CHANGE)
  100.                 {
  101.                     fc = col+dst_tc;
  102.                 }
  103.                 lc = col+dst_tc;
  104.             }
  105.             w1ptr++;
  106.             w2ptr++;
  107.         }
  108.  
  109.         if (*minchng == _NO_CHANGE)
  110.         {
  111.             *minchng = fc;
  112.             *maxchng = lc;
  113.         }
  114.         else    if (fc != _NO_CHANGE)
  115.         {
  116.             if (fc < *minchng)    *minchng = fc;
  117.             if (lc > *maxchng)    *maxchng = lc;
  118.         }
  119.         minchng++;
  120.         maxchng++;
  121.     }
  122.     return( OK );
  123. }
  124.  
  125. /*man-start*********************************************************************
  126.  
  127.   PDC_makenew()    - Create a WINDOW* (sans line allocation)
  128.  
  129.   PDCurses Description:
  130.      This is a private PDCurses routine.
  131.  
  132.      Allocates all data for a new WINDOW* except the actual lines
  133.      themselves.
  134.  
  135.   PDCurses Return Value:
  136.      This function returns a valid WINDOW* on success and NULL on error.
  137.  
  138.   PDCurses Errors:
  139.      If PDC_makenew() is unable to allocate memory for the window
  140.      structure, it will free all allocated memory and return
  141.      a NULL pointer.
  142.  
  143.   Portability:
  144.      PDCurses    WINDOW* PDC_makenew( int num_lines, int num_columns,
  145.                       int begy, int begx );
  146.  
  147. **man-end**********************************************************************/
  148.  
  149. WINDOW*    PDC_makenew(int num_lines, int num_columns, int begy, int begx)
  150. {
  151. extern    void*    (*mallc)( size_t );
  152. extern    void*    (*callc)( size_t, size_t );
  153. extern    void    (*fre)( void* );
  154.  
  155.     short    i=0;
  156.     WINDOW *win=NULL;
  157.  
  158. #ifdef PDCDEBUG
  159.     if (trace_on) PDC_debug("PDC_makenew() - called: lines %d cols %d begy %d begx %d\n",num_lines,num_columns,begy,begx);
  160. #endif
  161.  
  162.     /*
  163.     *    Use the standard runtime malloc/calloc package or use
  164.     *    the user's emalloc/ecalloc package.
  165.     *
  166.     *    Allocate the window structure itself
  167.     */
  168.     if ((win = (*mallc)(sizeof(WINDOW))) == (WINDOW *)NULL)
  169.     {
  170.         return( win );
  171.     }
  172.  
  173.     /*
  174.     * allocate the line pointer array
  175.     */
  176.     if ((win->_y = (*callc)(num_lines, sizeof(chtype *))) == NULL)
  177.     {
  178.         (*fre)(win);
  179.         return( (WINDOW *)NULL );
  180.     }
  181.  
  182.     /*
  183.     * allocate the minchng and maxchng arrays
  184.     */
  185.     if ((win->_firstch = (*callc)(num_lines, sizeof(int))) == NULL)
  186.     {
  187.         (*fre)(win->_y);
  188.         (*fre)(win);
  189.         return( (WINDOW *)NULL );
  190.     }
  191.     if ((win->_lastch = (*callc)(num_lines, sizeof(int))) == NULL)
  192.     {
  193.         (*fre)(win->_firstch);
  194.         (*fre)(win->_y);
  195.         (*fre)(win);
  196.         return( (WINDOW *)NULL );
  197.     }
  198.  
  199.     /*
  200.     * initialize window variables
  201.     */
  202.     win->_curx = 0;
  203.     win->_cury = 0;
  204.     win->_maxy = num_lines;        /* real max screen size */
  205.     win->_maxx = num_columns;    /* real max screen size */
  206.     win->_pmaxy = num_lines;    /* real max window size */
  207.     win->_pmaxx = num_columns;    /* real max window size */
  208.     win->_begy = begy;
  209.     win->_begx = begx;
  210.     win->_lastpy = 0;
  211.     win->_lastpx = 0;
  212.     win->_lastsy1 = 0;
  213.     win->_lastsx1 = 0;
  214.     win->_lastsy2 = LINES-1;
  215.     win->_lastsx2 = COLS-1;
  216.     win->_flags = 0;
  217.     win->_attrs = 0;        /* No attributes */
  218.     win->_tabsize = 8;
  219.     win->_clear = (bool) ((num_lines == LINES) && (num_columns == COLS));
  220.     win->_leave = FALSE;
  221.     win->_scroll = FALSE;
  222.     win->_nodelay = FALSE;
  223.     win->_use_keypad = FALSE;
  224.     win->_immed = FALSE;
  225.     win->_use_idl = FALSE;
  226.     win->_use_idc = TRUE;
  227.     win->_tmarg = 0;
  228.     win->_bmarg = num_lines - 1;
  229.     win->_title = NULL;
  230.     win->_title_ofs = 1;
  231.     win->_title_attr = win->_attrs;
  232.     win->_blank = ' ';
  233.     win->_parx = win->_pary = -1;
  234.     win->_parent = NULL;
  235. /* wrs 4/10/93 -- initialize background to blank */
  236.     win->_bkgd = ' ';
  237.     /*
  238.     * init to say window unchanged
  239.     */
  240.     for (i = 0; i < num_lines; i++)
  241.     {
  242.         win->_firstch[i] = 0;
  243.         win->_lastch[i] = num_columns - 1;
  244.     }
  245.  
  246.     /*
  247.     * set flags for window properties
  248.     */
  249.     if ((begy + num_lines) == LINES)
  250.     {
  251.         win->_flags |= _ENDLINE;
  252.         if ((begx == 0) &&
  253.             (num_columns == COLS) &&
  254.             (begy == 0))
  255.         {
  256.             win->_flags |= _FULLWIN;
  257.         }
  258.     }
  259.  
  260.     if (((begy + num_lines) == LINES) &&
  261.         ((begx + num_columns) == COLS))
  262.     {
  263.         win->_flags |= _SCROLLWIN;
  264.     }
  265.     return( win );
  266. }
  267.